package Year21_Month10.day1017;

/*
1. 实例1基本操作执行了2N+10次，通过推导大O阶方法知道，时间复杂度为 O(N)
2. 实例2基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(N+M)
3. 实例3基本操作执行了100次，通过推导大O阶方法，时间复杂度为 O(1)
4. 实例4基本操作执行最好N次，最坏执行了(N*(N-1))/2次，通过推导大O阶方法+时间复杂度一般看最坏，时间
复杂度为 O(N^2)
5. 实例5基本操作执行最好1次，最坏 次，时间复杂度为 O( ) ps： 在算法分析中表示是底数
为2，对数为N，有些地方会写成lgN。（建议通过折纸查找的方式讲解logN是怎么计算出来的）(因为二分查
找每次排除掉一半的不适合值,一次二分剩下：n/2
两次二分剩下：n/2/2 = n/4)
6. 实例6通过计算分析发现基本操作递归了N次，时间复杂度为O(N)。
7. 实例7通过计算分析发现基本操作递归了 次，时间复杂度为O( )。（建议画图递归栈帧的二叉树讲解）
 */
public class Fib {
    public static void main(String[] args) {

    }

    // 计算斐波那契递归fibonacci的时间复杂度？
    int fibonacci(int N) {
        return N < 3 ? N : fibonacci(N-1)+fibonacci(N-2);
    }

    // 计算阶乘递归factorial的时间复杂度？
    long factorial(int N) {
        return N < 2 ? N : factorial(N-1) * N;
    }

    int binarySearch(int[] array, int value) {
        int begin = 0;
        int end = array.length - 1;
        while (begin <= end) {
            int mid = begin + ((end - begin) / 2);
            if (array[mid] < value)
                begin = mid + 1;
            else if (array[mid] > value)
                end = mid - 1;
            else
                return mid;
        }
        return -1;
    }

        void bubbleSort(int[] array) {
        for (int end = array.length; end > 0; end--) {
            boolean sorted = true;
            for (int i = 1; i < end; i++) {
                if (array[i - 1] > array[i]) {
                    Swap(array, i - 1, i);
                    sorted = false;
                }
            }
            if (sorted == true) {
                break;
            }
        }
    }
    void Swap(int[] array,int i,int j){
        int tmp = array[i];
        array[i] = array[i + 1];
        array[i + 1] = tmp;
    }
    void func4(int N) {
        int count = 0;
        for (int k = 0; k < 100; k++) {
            count++;
        }
        System.out.println(count);
    }

    void func3(int N, int M) {
        int count = 0;
        for (int k = 0; k < M; k++) {
            count++;
        }
        for (int k = 0; k < N; k++) {
            count++;
        }
        System.out.println(count);
    }

    void func2(int N) {
        int count = 0;
        for (int k = 0; k < 2 * N ; k++) {
            count++;
        }
        int M = 10;
        while ((M--) > 0) {
            count++;
        }
        System.out.println(count);
    }

}
